home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 3d / mapgfx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  12.8 KB  |  416 lines
  1. #include "includes.h"
  2.  
  3.  int Quiet=FALSE;
  4.  
  5.  
  6.  void MapUsage()
  7.   {
  8.    printf("\nMapGfx - Mapping operations for bitmaps");
  9.    printf("\nUsage: mapgfx [-options] <command> <infile> <outfile>");
  10.    printf("\n\nCommands:");
  11.    printf("\n m     Map 2D image to 3D");
  12.    printf("\n r     Remap 3D sequence to 2D");
  13.    printf("\n 2     PSNR between 2D images");
  14.    printf("\n 3     PSNR between 3D sequences");
  15.    printf("\n p     Convert pgm to ppm");
  16.    printf("\n\nOptions:\n");
  17.    printf("\n -d<n>    Maximum 'x' size");
  18.    printf("\n -b<n>    Maximum 'y' size");
  19.    printf("\n -t<n>    Mapping type: 1 = Morton order");
  20.    printf("\n                        2 = x subsample");
  21.    printf("\n                        3 = y subsample");
  22.    printf("\n                        4 = Peano-Hilbert order");
  23.    printf("\n -q       Be quiet");
  24.    
  25.    MyExit(0);
  26.   }
  27.  
  28.  BitMap3D *MortonOrder(BitMap3D *Img)
  29.   {
  30.    register unsigned int i,j,k,l;
  31.    BitMap3D *Dst=GimmeABitMap3D(Img->XSize>>1,Img->YSize>>1,Img->ZSize<<2,Img->ImgType);
  32.    static level=0;
  33.    
  34.    for(i=0;i<Dst->XSize;i++)
  35.    for(j=0;j<Dst->YSize;j++)
  36.     {
  37.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][0*Img->ZSize+k]=Img->Map[(i<<1)  ][(j<<1)  ][k];
  38.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][1*Img->ZSize+k]=Img->Map[(i<<1)+1][(j<<1)  ][k];
  39.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][2*Img->ZSize+k]=Img->Map[(i<<1)  ][(j<<1)+1][k];
  40.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][3*Img->ZSize+k]=Img->Map[(i<<1)+1][(j<<1)+1][k];
  41.     }
  42.    FreeMeABitMap3D(Img);
  43.    return Dst;
  44.   }
  45.  
  46.  BitMap3D *DeMortonOrder(BitMap3D *Img)
  47.   {
  48.    register unsigned int i,j,k,l;
  49.    BitMap3D *Dst=GimmeABitMap3D(Img->XSize<<1,Img->YSize<<1,Img->ZSize>>2,Img->ImgType);
  50.    
  51.    for(i=0;i<Img->XSize;i++)
  52.    for(j=0;j<Img->YSize;j++)
  53.     {
  54.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)  ][(j<<1)  ][k]=Img->Map[i][j][0*Dst->ZSize+k];
  55.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)+1][(j<<1)  ][k]=Img->Map[i][j][1*Dst->ZSize+k];
  56.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)  ][(j<<1)+1][k]=Img->Map[i][j][2*Dst->ZSize+k];
  57.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)+1][(j<<1)+1][k]=Img->Map[i][j][3*Dst->ZSize+k];
  58.     }
  59.    FreeMeABitMap3D(Img);
  60.    return Dst;
  61.   }
  62.  
  63.  BitMap3D *PeanoOrder(BitMap3D *Img)
  64.   {
  65.    register unsigned int i,j,k,l;
  66.    BitMap3D *Dst=GimmeABitMap3D(Img->XSize>>1,Img->YSize>>1,Img->ZSize<<2,Img->ImgType);
  67.    static level=0;
  68.    
  69.    for(i=0;i<Dst->XSize;i++)
  70.    for(j=0;j<Dst->YSize;j++)
  71.     {
  72.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][0*Img->ZSize+k]=Img->Map[(i<<1)  ][(j<<1)  ][k];
  73.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][1*Img->ZSize+k]=Img->Map[(i<<1)+1][(j<<1)  ][k];
  74.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][2*Img->ZSize+k]=Img->Map[(i<<1)+1][(j<<1)+1][k];
  75.      for(k=0;k<Img->ZSize;k++) Dst->Map[i][j][3*Img->ZSize+k]=Img->Map[(i<<1)  ][(j<<1)+1][k];
  76.     }
  77.    FreeMeABitMap3D(Img);
  78.    return Dst;
  79.   }
  80.  
  81.  BitMap3D *DePeanoOrder(BitMap3D *Img)
  82.   {
  83.    register unsigned int i,j,k,l;
  84.    BitMap3D *Dst=GimmeABitMap3D(Img->XSize<<1,Img->YSize<<1,Img->ZSize>>2,Img->ImgType);
  85.    
  86.    for(i=0;i<Img->XSize;i++)
  87.    for(j=0;j<Img->YSize;j++)
  88.     {
  89.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)  ][(j<<1)  ][k]=Img->Map[i][j][0*Dst->ZSize+k];
  90.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)+1][(j<<1)  ][k]=Img->Map[i][j][1*Dst->ZSize+k];
  91.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1)+1][(j<<1)+1][k]=Img->Map[i][j][2*Dst->ZSize+k];
  92.      for(k=0;k<Dst->ZSize;k++) Dst->Map[(i<<1) ][(j<<1)+1][k]=Img->Map[i][j][3*Dst->ZSize+k];
  93.     }
  94.    FreeMeABitMap3D(Img);
  95.    return Dst;
  96.   }
  97.  
  98.  void main(int argc,char *argv[])
  99.   {
  100.    char c;
  101.    char *filename1,*filename2,*cmd,*dd;
  102.    int block=2,depth=1,type=1,i;
  103.    
  104.    Quiet=FALSE;
  105.    
  106.    if (argc<4) MapUsage();
  107.    while(--argc>3)
  108.     {
  109.      c=(*++argv)[0];
  110.      if (!(c=='-')) ErrorHandler(UNKNOWN_OPTION,argv[0]);
  111.      else
  112.       {
  113.        c=(*argv)[1];
  114.        dd= &(*argv)[1];
  115.        switch(c)
  116.         {
  117.          case 't': type=ReadInteger(&((*argv)[2]));
  118.          break;
  119.          case 'b': block=ReadInteger(&((*argv)[2]));
  120.          break;
  121.          case 'd': depth=ReadInteger(&((*argv)[2]));
  122.          break;
  123.          case 'q': Quiet=TRUE;
  124.          break;
  125.          default: ErrorHandler(UNKNOWN_OPTION,argv[0]);
  126.          break;
  127.         }
  128.       }
  129.     }
  130.    
  131.    cmd = &(*++argv)[0];
  132.    filename1 = &(*++argv)[0];
  133.    filename2 = &(*++argv)[0];
  134.    
  135.    c=cmd[0];
  136.    switch(c)
  137.     {
  138.      case 'c': /* convert 2D image to 3D */
  139.       {
  140.        BitMap *Src;
  141.        vpf(stderr,"Converting  bitmap '%s' to sequence '%s'...",filename1,filename2);
  142.        Src=LoadBitMap(filename1,0,0,0,0,block,""); /* load image */
  143.        
  144.        switch(type)
  145.         {
  146.          case 1: /* Morton order */
  147.           {
  148.            BitMap *Tmp;
  149.            BitMap3D *Dst;
  150.            register int x,y,z,i,j,k=0;
  151.            
  152.            vpf(stderr,"\nMapping of 2D image to 3D using Morton Order...");
  153.            x=Src->XSize;
  154.            y=Src->YSize;
  155.            z=depth;
  156.            vprintf(stderr,"\n   Depth:%d",z);
  157.            Dst=GimmeABitMap3D(x,y,1,Src->ImgType);
  158.            BitMap2Frame(Src,Dst,0); /* copy frame to 3d map */
  159.            FreeMeABitMap(Src);
  160.            
  161.            for(i=0;i<z;i++) 
  162.             {
  163.              vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  164.              Dst=MortonOrder(Dst);
  165.             }
  166.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  167.            SaveBitMap3D(filename2,Dst,"");
  168.           }
  169.          break;
  170.          case 2: /* x subsample */
  171.           {
  172.            BitMap *Tmp;
  173.            BitMap3D *Dst;
  174.            register int x,y,z,i,j,k=0;
  175.            
  176.            vpf(stderr,"\nMapping of 2D image to 3D using x subsample...");
  177.            x=Src->XSize/depth;
  178.            y=Src->YSize;
  179.            z=depth;
  180.            vprintf(stderr,"\n   Depth:%d",depth);
  181.            Dst=GimmeABitMap3D(x,y,z,Src->ImgType);
  182.            
  183.            for(i=0;i<x;i++) 
  184.            for(j=0;j<y;j++) 
  185.            for(k=0;k<z;k++) Dst->Map[i][j][k]=Src->Map[i*z+k][j];
  186.            
  187.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  188.            SaveBitMap3D(filename2,Dst,"");
  189.           }
  190.          break;
  191.          case 3: /* y subsample */
  192.           {
  193.            BitMap *Tmp;
  194.            BitMap3D *Dst;
  195.            register int x,y,z,i,j,k=0;
  196.            
  197.            vpf(stderr,"\nMapping of 2D image to 3D using y subsample...");
  198.            x=Src->XSize;
  199.            y=Src->YSize/depth;
  200.            z=depth;
  201.            vprintf(stderr,"\n   Depth:%d",depth);
  202.            Dst=GimmeABitMap3D(x,y,z,Src->ImgType);
  203.            
  204.            for(i=0;i<x;i++) 
  205.            for(j=0;j<y;j++) 
  206.            for(k=0;k<z;k++) Dst->Map[i][j][k]=Src->Map[i][j*z+k];
  207.            
  208.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  209.            SaveBitMap3D(filename2,Dst,"");
  210.           }
  211.          break;
  212.          case 4: /* Peano order */
  213.           {
  214.            BitMap *Tmp;
  215.            BitMap3D *Dst;
  216.            register int x,y,z,i,j,k=0;
  217.            
  218.            vpf(stderr,"\nMapping of 2D image to 3D using Peano-Hilbert Order...");
  219.            x=Src->XSize;
  220.            y=Src->YSize;
  221.            z=depth;
  222.            vprintf(stderr,"\n   Depth:%d",z);
  223.            Dst=GimmeABitMap3D(x,y,1,Src->ImgType);
  224.            BitMap2Frame(Src,Dst,0); /* copy frame to 3d map */
  225.            FreeMeABitMap(Src);
  226.            
  227.            for(i=0;i<z;i++) 
  228.             {
  229.              vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  230.              Dst=PeanoOrder(Dst);
  231.             }
  232.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Dst->XSize,Dst->YSize,Dst->ZSize);
  233.            SaveBitMap3D(filename2,Dst,"");
  234.           }
  235.          break;
  236.          
  237.          case 9: /* dum conversion - just plain collage */
  238.           {
  239.            BitMap *Tmp;
  240.            BitMap3D *Dst;
  241.            register int x,y,z,i,j,k=0;
  242.            
  243.            vpf(stderr,"\nMapping of 2D image to 3D using plain collage");
  244.            
  245.            x=(Src->XSize/block)*block/depth;
  246.            y=(Src->YSize/block)*block/depth;
  247.            z=depth<<2;
  248.            
  249.            Dst=GimmeABitMap3D(x,y,z,Src->ImgType);
  250.            Tmp=GimmeABitMap(x,y,Src->ImgType);
  251.            vpf(stderr,"New image size:(%d,%d,%d)",x,y,z);
  252.            
  253.            for(i=0;i<(Src->XSize/block)*block/x;i++)
  254.            for(j=0;j<(Src->YSize/block)*block/y;j++)
  255.             {
  256.              Map2BitMap(Src,Tmp,i*x,j*y);
  257.              BitMap2Frame(Tmp,Dst,k++);
  258.             }
  259.            SaveBitMap3D(filename2,Dst,"");
  260.           }
  261.          break;
  262.          
  263.          default:
  264.          break;
  265.          
  266.         }
  267.        vprintf(stderr,"\n");
  268.        exit(0);
  269.       }
  270.      break;
  271.      
  272.      case 'r':  /* reconvert 3D image to 2D */
  273.       {
  274.        BitMap3D *Src;
  275.        vpf(stderr,"\nConverting  sequence '%s' to bitmap '%s'...",filename1,filename2);
  276.        Src=LoadBitMap3D(filename1,0,0,0,0,0,1,""); /* load image */
  277.        
  278.        switch(type)
  279.         {
  280.          case 1: /* Morton order */
  281.           {
  282.            BitMap *Dst;
  283.            register int x,y,z,i,j,k=0;
  284.            
  285.            vpf(stderr,"\nRe-mapping of 3D image to 2D using Morton Order...");
  286.            z=(int)(sqrt(Src->ZSize)+0.5)>>1;
  287.            for(i=0;i<z;i++) 
  288.             {
  289.              vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Src->XSize,Src->YSize,Src->ZSize);
  290.              Src=DeMortonOrder(Src);
  291.             }
  292.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Src->XSize,Src->YSize,Src->ZSize);
  293.            Dst=GimmeABitMap(Src->XSize,Src->YSize,GRAYIMG);
  294.            Frame2BitMap(Src,0,Dst);
  295.            SaveBitMap(filename2,Dst,"");
  296.           }
  297.          break;
  298.          case 2: /* x subsample */
  299.           {
  300.            BitMap *Dst;
  301.            register int x,y,z,i,j,k=0;
  302.            
  303.            vpf(stderr,"\nRe-Mapping of 3D image to 2D using x subsample...");
  304.            z=Src->ZSize;
  305.            
  306.            x=Src->XSize;
  307.            y=Src->YSize;
  308.            
  309.            Dst=GimmeABitMap(x*z,y,Src->ImgType);
  310.            
  311.            for(i=0;i<x;i++) 
  312.            for(j=0;j<y;j++) 
  313.            for(k=0;k<z;k++) Dst->Map[i*z+k][j]=Src->Map[i][j][k];
  314.            
  315.            vpf(stderr,"\n   Image:(%d,%d)",Dst->XSize,Dst->YSize);
  316.            SaveBitMap(filename2,Dst,"");
  317.           }
  318.          break;
  319.          case 3: /* y subsample */
  320.           {
  321.            BitMap *Dst;
  322.            register int x,y,z,i,j,k=0;
  323.            
  324.            vpf(stderr,"\nRe-Mapping of 3D image to 2D using y subsample...");
  325.            z=Src->ZSize;
  326.            
  327.            x=Src->XSize;
  328.            y=Src->YSize;
  329.            
  330.            Dst=GimmeABitMap(x,y*z,Src->ImgType);
  331.            
  332.            for(i=0;i<x;i++) 
  333.            for(j=0;j<y;j++) 
  334.            for(k=0;k<z;k++) Dst->Map[i][j*z+k]=Src->Map[i][j][k];
  335.            vpf(stderr,"\n   Image:(%d,%d)",Dst->XSize,Dst->YSize);
  336.            SaveBitMap(filename2,Dst,"");
  337.           }
  338.          break;
  339.          case 4: /* Peano order */
  340.           {
  341.            BitMap *Dst;
  342.            register int x,y,z,i,j,k=0;
  343.            
  344.            vpf(stderr,"\nRe-mapping of 3D image to 2D using Peano-Hilbert Order...");
  345.            z=(int)(sqrt(Src->ZSize)+0.5)>>1;
  346.            for(i=0;i<z;i++) 
  347.             {
  348.              vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Src->XSize,Src->YSize,Src->ZSize);
  349.              Src=DePeanoOrder(Src);
  350.             }
  351.            vpf(stderr,"\n   Level:%d  Image:(%d,%d,%d)",i,Src->XSize,Src->YSize,Src->ZSize);
  352.            Dst=GimmeABitMap(Src->XSize,Src->YSize,GRAYIMG);
  353.            Frame2BitMap(Src,0,Dst);
  354.            SaveBitMap(filename2,Dst,"");
  355.           }
  356.          
  357.          default:
  358.          break;
  359.         }
  360.        vprintf(stderr,"\n");
  361.        exit(0);
  362.       }
  363.      break;
  364.      
  365.      
  366.      
  367. /*     case '2':  2d psnr 
  368.       {
  369.        BitMap *Src1=LoadBitMap(filename1,0,0,0,0,1,"");
  370.        BitMap *Src2=LoadBitMap(filename2,0,0,0,0,1,"");
  371.        vprintf(stderr,"\nPSNR between '%s' and '%s: %f [dB]",PSNR(Src1,Src2));
  372.       }
  373.      break;
  374. */
  375.      case '3': /* 3d psnr */
  376.       {
  377.        BitMap3D *Src1=LoadBitMap3D(filename1,0,0,0,0,0,1,"");
  378.        BitMap3D *Src2=LoadBitMap3D(filename2,0,0,0,0,0,1,"");
  379.        vprintf(stderr,"\nPSNR between '%s' and '%s: %f [dB]",PSNR3D(Src1,Src2));
  380.       }
  381.      break;
  382.      
  383.      case 'p':  /* pgm file to ppm */
  384.       {
  385.        BitMap *Src;
  386.        BitMap *Dst;
  387.        register unsigned int i,j,k,l;
  388.        
  389.        vprintf(stderr,"Converting PGM file '%s' to PPM file '%s'...",filename1,filename2);
  390.        
  391.        Quiet=TRUE;
  392.        Src=LoadBitMap(filename1,0,0,0,0,1,""); /* load image */
  393.        if (Src->ImgType!=GRAYIMG) ErrorHandler(WRONG_FORMAT,"Not a PGM file");
  394.        Dst=GimmeABitMap(Src->XSize,3*Src->YSize,RGBIMG);
  395.        l=Src->YSize;
  396.        
  397.        for(i=0;i<Src->XSize;i++)
  398.        for(j=0;j<Src->YSize;j++)
  399.         {
  400.          k=(Src->Map[i][j]);
  401.          Dst->Map[i][j]    =k;
  402.          Dst->Map[i][j+l]  =k;
  403.          Dst->Map[i][j+l*2]=k;
  404.         }
  405.        
  406.        SaveBitMap(filename2,Dst,"");
  407.        
  408.        vprintf(stderr,"\nDone!\n");
  409.       }
  410.      break;
  411.     }
  412.    
  413.   }
  414.  
  415.  
  416.